package com.chen.cart.service.impl;

import cn.hutool.core.collection.CollectionUtil;
import com.alibaba.fastjson.JSON;
import com.chen.cart.service.CartService;
import com.chen.feign.product.ProductFeignClient;
import com.chen.model.entity.h5.CartInfo;
import com.chen.model.entity.product.ProductSku;
import com.chen.model.entity.user.UserInfo;

import com.chen.service.util.AuthContextUtil;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.Date;
import java.util.List;
import java.util.stream.Collectors;

/**
 * @author cgj
 * @date 4/22/25 8:00 PM
 */
@Service
public class CartServiceImpl implements CartService {

    @Autowired
    private RedisTemplate<String, String> redisTemplate;
    @Autowired
    private ProductFeignClient productFeignClient;

    /**
     * 加入购物车
     * 用hash 类型   key  filed value
     * userId   skuId  skuInfo
     * 第一次
     * userid1   skuId 10  skuInfo
     * 第二次
     * skuId 10  skuInfo
     * userId1
     * skuId 11 skuInfo
     * 第三次, 相同的商品sku
     * <p>
     * skuId 10  skuInfo  num+1
     * userId1
     * skuId 11 skuInfo
     *
     * @param skuId
     * @param skuNum
     */
    @Override
    public void addToCart(Long skuId, Integer skuNum) {
        //  从本地线程中获取用户信息
        UserInfo userInfo = AuthContextUtil.get();
        Long userid = userInfo.getId();
        String carId = "user:cart:" + userid;
        CartInfo cartInfo = null;
        // 判断是否存在当前加入的sku
        Boolean result = redisTemplate.opsForHash().hasKey(carId, String.valueOf(skuId));
        if (result) {
            //如果有就只增加数量
            //获取购物车对象
            String cartJson = (String) redisTemplate.opsForHash().get(carId, String.valueOf(skuId));
            cartInfo = JSON.parseObject(cartJson, CartInfo.class);
            //更新数量
            cartInfo.setSkuNum(cartInfo.getSkuNum() + skuNum);
            //设置状态
            cartInfo.setIsChecked(1);
            // 更新时间
            cartInfo.setUpdateTime(new Date());
        } else {
            //没有需要新增一个购物车
            cartInfo = new CartInfo();
            cartInfo.setUserId(userid);
            cartInfo.setSkuId(skuId);
            //根据skuId查询,详细信息如缩略图,价格等
            ProductSku skuInfo = productFeignClient.getProductSkuBySkuId(skuId);
            cartInfo.setCartPrice(skuInfo.getSalePrice());
            cartInfo.setSkuNum(skuNum);
            cartInfo.setImgUrl(skuInfo.getThumbImg());
            cartInfo.setSkuName(skuInfo.getSkuName());
            //是否被选中
            cartInfo.setIsChecked(1);
            cartInfo.setUpdateTime(new Date());
            cartInfo.setCreateTime(new Date());
        }

        // 存储到redis
        redisTemplate.opsForHash().put(carId, String.valueOf(skuId), JSON.toJSONString(cartInfo));

    }

    /**
     * 当前用户购物车列表查询
     *
     * @return
     */
    @Override
    public List<CartInfo> cartList() {
        //获取用户id
        UserInfo userInfo = AuthContextUtil.get();
        Long userid = userInfo.getId();
        //获取购物车
        List<Object> cartList = redisTemplate.opsForHash().values("user:cart:" + userid);
        //为空返回空集合
        if (CollectionUtil.isEmpty(cartList)) {
            return new ArrayList<>();
        }
        List<CartInfo> cartInfoList = cartList.stream().map(cart -> {
            return JSON.parseObject(cart.toString(), CartInfo.class);
        }).collect(Collectors.toList());
        //对集合进行排序, 根据updateTime
        List<CartInfo> sortedList = cartInfoList.stream().sorted(new Comparator<CartInfo>() {
            @Override
            public int compare(CartInfo o1, CartInfo o2) {
                return o1.getUpdateTime().compareTo(o2.getUpdateTime());
            }
        }).collect(Collectors.toList());
        return sortedList;
    }

    /**
     * 删除购物车项
     *
     * @param skuId
     */
    @Override
    public void deleteCart(Long skuId) {
        //获取当前用户的id
        UserInfo userInfo = AuthContextUtil.get();
        String cartId = getCartID(userInfo.getId());
        redisTemplate.opsForHash().delete(cartId,skuId.toString()); // delete删除的是小key(也就是field)
    }

    /**
     * 修改商品选中状态
     * @param skuId
     * @param checkStatus
     */
    @Override
    public void checkCart(long skuId, Integer checkStatus) {
           //获取用户id
        Long userid = AuthContextUtil.get().getId();
        String cartID = getCartID(userid);
        //获取购物车对象
        Object o = redisTemplate.opsForHash().get(cartID, String.valueOf(skuId));
        System.out.println(o);
        CartInfo cartInfo = JSON.parseObject(o.toString(), CartInfo.class);
        cartInfo.setIsChecked(checkStatus);
        System.out.println(cartInfo.getIsChecked());
        //保存回去
        redisTemplate.opsForHash().put(cartID,String.valueOf(skuId), JSON.toJSONString(cartInfo));
    }

    /**
     * 购物车商品全部选中,或者不选中
     * @param status
     */
    @Override
    public void allCheckCart(Integer status) {
        // 获取购物车id
        String cartID = getCartID(AuthContextUtil.get().getId());
        // 把对应全部商品查出来
        List<Object> objectList = redisTemplate.opsForHash().values(cartID); //values是获取全部key 所对应的field 和 value
        if(CollectionUtil.isEmpty(objectList)){
             return;
        }
        System.out.println(objectList);
        //转换类型
       objectList.stream().forEach(item -> {
            //拿到购物车对象
            String jsonString = item.toString();
            CartInfo cartInfo = JSON.parseObject(jsonString, CartInfo.class);
            //设置状态
            cartInfo.setIsChecked(status);
            //存储回redis
            redisTemplate.opsForHash().put(cartID,cartInfo.getSkuId().toString(),JSON.toJSONString(cartInfo));
    });



    }

    /**
     * 清空购物车
     */
    @Override
    public void clearCart() {
        // 获取购物车id
        String cartID = getCartID(AuthContextUtil.get().getId());
        //删除次id
        redisTemplate.delete(cartID);// delete 直接把对应用户id购物车删除即可
    }

    /**
     * 获取选中的全部购物车项的列表
     * @return
     */
    @Override
    public List<CartInfo> getAllChecked() {
        //用户ID
        Long userid = AuthContextUtil.get().getId();
        //获取购物车id
        String cartID = getCartID(userid);
        //获取当前用户的购物车,并进行便利, 判断是否被选中
        List<Object> objectList = redisTemplate.opsForHash().values(cartID);
        if(CollectionUtil.isEmpty(objectList)){
            return new ArrayList<>();
        }
        // objectList 是一个json字符串的集合
        List<CartInfo> cartInfoList = objectList.stream().map(item ->
               JSON.parseObject(item.toString(), CartInfo.class)
        ).filter(cartInfo ->
             cartInfo.getIsChecked() == 1
       ).collect(Collectors.toList());
        return  cartInfoList;
    }

    /**
     *  删除用户选中的购物车项目
     */
    @Override
    public void deleteChecked() {
      //  获取选中的全部购物车项的列表
        List<CartInfo> allChecked = getAllChecked();
        for (CartInfo cartInfo : allChecked) {
            Long skuId = cartInfo.getSkuId();
            //删除订单项目
            deleteCart(skuId);
        }
    }

    /**
     * 获取cartId
     * @param userid
     * @return
     */
    private String getCartID(Long userid) {
        return "user:cart:" + userid;
    }

    /**
     * stream排序集合内容练习
     *
     * @param args
     */
    public static void main(String[] args) {
        ArrayList<Integer> num = new ArrayList<>();
        num.add(4);
        num.add(3);
        num.add(9);
        num.add(7);
//        List<Integer> sorted = num.stream().sorted(new Comparator<Integer>() {
//            @Override
//            public int compare(Integer o1, Integer o2) {
//                return o2 - o1;  //降序
//            }
//        }).collect(Collectors.toList());
//        List<Integer> sortedList = num.stream().sorted((n, m) -> Integer.compare(n, m)).collect(Collectors.toList());
//
//        System.out.println(sortedList);


    }
}
